package handlers

import (
	"data_service/models"
	"data_service/server"
	"data_service/utils"
	"errors"
	"fmt"
	"net/http"
	"strconv"
	"strings"
	"time"

	"gorm.io/gorm"

	"github.com/gin-gonic/gin"
)

// 初始化用户业务服务
var userService = server.NewUserService()

// UpdateAvatar 更新用户头像
func UpdateAvatar(c *gin.Context) {
	fmt.Printf("[AVATAR] 收到头像更新请求 - IP: %s\n", c.ClientIP())

	var req struct {
		Email  string `json:"email" binding:"required,email"`
		Avatar string `json:"avatar" binding:"required"`
	}
	if err := c.ShouldBindJSON(&req); err != nil {
		utils.Logger.Error().Err(err).Str("ip", c.ClientIP()).Msg("头像更新JSON解析失败")
		c.JSON(http.StatusBadRequest, gin.H{
			"code":    "INVALID_JSON_FORMAT",
			"message": "请求参数格式错误",
			"data":    gin.H{"details": "请检查JSON格式是否正确"},
		})
		return
	}

	fmt.Printf("[AVATAR] 解析成功 - 邮箱: %s, 头像长度: %d\n", req.Email, len(req.Avatar))

	// 验证头像URL长度（限制为1MB，约1,048,576字符）
	if len(req.Avatar) > 1048576 {
		fmt.Printf("[AVATAR] 头像数据过大 - 长度: %d\n", len(req.Avatar))
		c.JSON(http.StatusBadRequest, gin.H{
			"code":    "AVATAR_TOO_LARGE",
			"message": "头像数据过大",
			"data":    gin.H{"details": "请选择较小的图片"},
		})
		return
	}

	// 通过邮箱查找用户
	fmt.Printf("[AVATAR] 查找用户 - 邮箱: %s\n", req.Email)
	user, err := userService.GetUserByEmail(req.Email)
	if err != nil || user == nil {
		utils.Logger.Warn().Str("email", req.Email).Str("ip", c.ClientIP()).Msg("头像更新失败：用户不存在")
		c.JSON(http.StatusNotFound, gin.H{
			"code":    "USER_NOT_FOUND",
			"message": "用户不存在",
			"data":    gin.H{"details": "未找到指定邮箱的用户"},
		})
		return
	}

	fmt.Printf("[AVATAR] 开始更新头像 - 用户ID: %d, 邮箱: %s\n", user.ID, req.Email)
	if err := userService.UpdateAvatarURL(int(user.ID), req.Avatar); err != nil {
		utils.Logger.Error().Err(err).Uint("user_id", user.ID).Str("email", req.Email).Msg("头像更新数据库操作失败")
		c.JSON(http.StatusInternalServerError, gin.H{
			"code":    "AVATAR_UPDATE_FAILED",
			"message": "头像更新失败",
			"data":    gin.H{"details": "服务器内部错误，请稍后重试"},
		})
		return
	}

	utils.Logger.Info().Uint("user_id", user.ID).Str("email", req.Email).Msg("头像更新成功")
	c.JSON(http.StatusOK, gin.H{
		"code":    "SUCCESS",
		"message": "头像更新成功",
		"data":    gin.H{"avatar": req.Avatar},
	})
}

// Register 处理新用户注册
func Register(c *gin.Context) {
	fmt.Printf("[REGISTER] 收到注册请求 - IP: %s, User-Agent: %s\n", c.ClientIP(), c.GetHeader("User-Agent"))

	var req models.User
	if err := c.ShouldBindJSON(&req); err != nil {
		utils.Logger.Error().Err(err).Str("ip", c.ClientIP()).Msg("用户注册JSON解析失败")
		c.JSON(http.StatusBadRequest, gin.H{
			"code":    "INVALID_JSON_FORMAT",
			"message": "请求参数格式错误",
			"data":    gin.H{"details": "请检查JSON格式是否正确"},
		})
		return
	}

	fmt.Printf("[REGISTER] 解析成功 - 用户名: %s, 邮箱: %s\n", req.Name, req.Email)

	// 使用通用验证函数检查必填字段
	missingFields := utils.ValidateRequiredFields(map[string]string{
		"用户名":  req.Name,
		"邮箱地址": req.Email,
		"密码":   req.Password,
	})

	if len(missingFields) > 0 {
		fmt.Printf("[REGISTER] 参数验证失败 - 缺少字段: %v\n", missingFields)
		c.JSON(http.StatusBadRequest, gin.H{
			"code":    "MISSING_REQUIRED_FIELDS",
			"message": "必填字段不能为空",
			"data": gin.H{
				"details":        fmt.Sprintf("缺少以下字段: %s", strings.Join(missingFields, ", ")),
				"missing_fields": missingFields,
			},
		})
		return
	}

	// 邮箱格式验证
	if !utils.IsValidEmail(req.Email) {
		fmt.Printf("[REGISTER] 邮箱格式验证失败 - 邮箱: %s\n", req.Email)
		c.JSON(http.StatusBadRequest, gin.H{
			"code":    "INVALID_EMAIL_FORMAT",
			"message": "邮箱格式不正确",
			"data":    gin.H{"details": "请输入有效的邮箱地址"},
		})
		return
	}

	// 使用通用验证函数检查密码强度
	if err := utils.ValidatePassword(req.Password); err != nil {
		fmt.Printf("[REGISTER] 密码强度验证失败: %v\n", err)
		c.JSON(http.StatusBadRequest, gin.H{
			"code":    "PASSWORD_TOO_SHORT",
			"message": "密码长度不足",
			"data":    gin.H{"details": err.Error()},
		})
		return
	}

	// 使用通用验证函数检查用户名长度
	if err := utils.ValidateUsername(req.Name); err != nil {
		fmt.Printf("[REGISTER] 用户名验证失败: %v\n", err)
		c.JSON(http.StatusBadRequest, gin.H{
			"code":    "USERNAME_TOO_SHORT",
			"message": "用户名长度不足",
			"data":    gin.H{"details": err.Error()},
		})
		return
	}

	// 初始化LastLogin字段，避免数据库datetime错误
	req.LastLogin = time.Now()

	// 检查邮箱是否已存在
	fmt.Printf("[REGISTER] 检查邮箱是否已存在 - 邮箱: %s\n", req.Email)
	if userService.IsEmailExist(req.Email) {
		utils.Logger.Warn().Str("email", req.Email).Str("ip", c.ClientIP()).Msg("注册失败：邮箱已存在")
		c.JSON(http.StatusConflict, gin.H{
			"code":    "EMAIL_ALREADY_EXISTS",
			"message": "邮箱已被注册",
			"data": gin.H{
				"details":    fmt.Sprintf("邮箱 %s 已经被其他用户注册，请使用其他邮箱或尝试登录", req.Email),
				"suggestion": "请尝试使用其他邮箱地址，或点击登录按钮使用现有账号登录",
			},
		})
		return
	}

	// 尝试注册用户
	fmt.Printf("[REGISTER] 开始注册用户 - 用户名: %s, 邮箱: %s\n", req.Name, req.Email)
	if err := userService.Register(&req); err != nil {
		utils.Logger.Error().Err(err).Str("email", req.Email).Str("username", req.Name).Msg("用户注册数据库操作失败")
		c.JSON(http.StatusInternalServerError, gin.H{
			"code":    "DATABASE_ERROR",
			"message": "注册失败",
			"data":    gin.H{"details": "服务器内部错误，请稍后重试"},
		})
		return
	}

	utils.Logger.Info().Uint("user_id", req.ID).Str("username", req.Name).Str("email", req.Email).Msg("用户注册成功")
	c.JSON(http.StatusOK, gin.H{
		"code":    "SUCCESS",
		"message": "注册成功",
		"data": gin.H{
			"user": gin.H{
				"id":    req.ID,
				"name":  req.Name,
				"email": req.Email,
				"role":  req.Role,
			},
			"details": fmt.Sprintf("用户 %s 注册成功，请使用邮箱 %s 登录", req.Name, req.Email),
		},
	})
}

// Login 处理用户登录
func Login(c *gin.Context) {
	fmt.Printf("[LOGIN] 收到登录请求 - IP: %s, User-Agent: %s\n", c.ClientIP(), c.GetHeader("User-Agent"))

	var req struct {
		Email    string `json:"email" binding:"required,email"`
		Password string `json:"password" binding:"required"`
	}
	if err := c.ShouldBindJSON(&req); err != nil {
		utils.Logger.Error().Err(err).Str("ip", c.ClientIP()).Msg("用户登录JSON解析失败")
		c.JSON(http.StatusBadRequest, gin.H{
			"code":    "INVALID_LOGIN_FORMAT",
			"message": "登录数据格式错误",
			"data":    gin.H{"details": "请检查邮箱和密码格式是否正确"},
		})
		return
	}

	fmt.Printf("[LOGIN] 解析成功 - 邮箱: %s\n", req.Email)

	// 基本验证
	if req.Email == "" || req.Password == "" {
		fmt.Printf("[LOGIN] 参数验证失败 - 邮箱或密码为空\n")
		c.JSON(http.StatusBadRequest, gin.H{
			"code":    "MISSING_LOGIN_CREDENTIALS",
			"message": "邮箱和密码不能为空",
			"data":    gin.H{"details": "请填写完整的登录信息"},
		})
		return
	}

	// 邮箱格式验证
	if !utils.IsValidEmail(req.Email) {
		fmt.Printf("[LOGIN] 邮箱格式验证失败 - 邮箱: %s\n", req.Email)
		c.JSON(http.StatusBadRequest, gin.H{
			"code":    "INVALID_EMAIL_FORMAT",
			"message": "邮箱格式不正确",
			"data":    gin.H{"details": "请输入有效的邮箱地址"},
		})
		return
	}

	fmt.Printf("[LOGIN] 开始验证用户凭据 - 邮箱: %s\n", req.Email)
	user, err := userService.Login(req.Email, req.Password)
	if err != nil {
		utils.Logger.Warn().Str("email", req.Email).Str("ip", c.ClientIP()).Err(err).Msg("用户登录验证失败")

		// 根据错误类型返回不同的错误信息
		if strings.Contains(err.Error(), "用户不存在") {
			fmt.Printf("[LOGIN] 用户不存在 - 邮箱: %s\n", req.Email)
			c.JSON(http.StatusUnauthorized, gin.H{
				"code":    "USER_NOT_FOUND",
				"message": "用户不存在",
				"data": gin.H{
					"details":    fmt.Sprintf("邮箱 %s 未注册，请先注册账号", req.Email),
					"suggestion": "请检查邮箱地址是否正确，或点击注册按钮创建新账号",
				},
			})
		} else if strings.Contains(err.Error(), "密码错误") {
			fmt.Printf("[LOGIN] 密码错误 - 邮箱: %s\n", req.Email)
			c.JSON(http.StatusUnauthorized, gin.H{
				"code":    "INVALID_PASSWORD",
				"message": "密码错误",
				"data": gin.H{
					"details":    "输入的密码不正确，请重新输入",
					"suggestion": "请检查密码是否正确，注意大小写",
				},
			})
		} else {
			fmt.Printf("[LOGIN] 其他登录错误 - 邮箱: %s, 错误: %v\n", req.Email, err)
			c.JSON(http.StatusUnauthorized, gin.H{
				"code":    "LOGIN_FAILED",
				"message": "登录失败",
				"data":    gin.H{"details": "邮箱或密码错误，请重新输入"},
			})
		}
		return
	}

	if user.Status == models.StatusBanned {
		utils.Logger.Warn().Uint("user_id", user.ID).Str("email", user.Email).Str("ip", c.ClientIP()).Msg("被封禁用户尝试登录")
		c.JSON(http.StatusForbidden, gin.H{
			"code":    "ACCOUNT_BANNED",
			"message": "账户已被封禁",
			"data": gin.H{
				"details":    "您的账户已被管理员封禁，无法登录",
				"suggestion": "如需解封，请联系系统管理员",
			},
		})
		return
	}

	// 清除密码信息，不返回给前端
	user.Password = ""

	// 确保CreatedAt字段有正确的值
	if user.CreatedAt.IsZero() {
		user.CreatedAt = user.Model.CreatedAt
	}

	// 记录登录信息用于调试
	utils.Logger.Info().Uint("user_id", user.ID).Str("username", user.Name).Str("email", user.Email).Str("role", user.Role).Str("ip", c.ClientIP()).Msg("用户登录成功")

	c.JSON(http.StatusOK, gin.H{
		"code":    "SUCCESS",
		"message": "登录成功",
		"data": gin.H{
			"user":       user,
			"user_id":    user.ID,
			"user_name":  user.Name,
			"user_email": user.Email,
			"role":       user.Role,
			"created_at": user.CreatedAt,
		},
	})
}

// GetUserInfo 获取单个用户详细信息（通过邮箱查询）
func GetUserInfo(c *gin.Context) {
	fmt.Printf("[GET_USER_INFO] 收到获取用户信息请求 - 邮箱: %s\n", c.Param("id"))

	email := c.Param("id") // 这里的id参数实际上是邮箱
	user, err := userService.GetUserByID(email)
	if err != nil || user == nil {
		fmt.Printf("[GET_USER_INFO] 用户不存在 - 邮箱: %s, 错误: %v\n", email, err)
		c.JSON(http.StatusNotFound, gin.H{
			"code":    "USER_NOT_FOUND",
			"message": "用户不存在",
			"data":    gin.H{"details": "未找到指定邮箱的用户"},
		})
		return
	}
	user.Password = ""

	// 确保CreatedAt字段有正确的值
	if user.CreatedAt.IsZero() {
		user.CreatedAt = user.Model.CreatedAt
	}

	fmt.Printf("[GET_USER_INFO] 获取成功 - 用户ID: %d, 邮箱: %s\n", user.ID, user.Email)

	// 确保ID字段正确序列化
	userData := gin.H{
		"id":         user.ID,
		"name":       user.Name,
		"email":      user.Email,
		"role":       user.Role,
		"status":     user.Status,
		"level":      user.Level,
		"points":     user.Points,
		"avatar":     user.Avatar,
		"created_at": user.CreatedAt,
		"last_login": user.LastLogin,
	}

	c.JSON(http.StatusOK, gin.H{
		"code":    "SUCCESS",
		"message": "获取用户信息成功",
		"data":    userData,
	})
}

// UpdateUserInfo 更新用户信息
func UpdateUserInfo(c *gin.Context) {
	fmt.Printf("[UPDATE_USER_INFO] 收到更新用户信息请求 - 邮箱: %s\n", c.Param("id"))

	email := c.Param("id") // 使用邮箱作为参数

	var req struct {
		Name string `json:"name" binding:"required"`
	}
	if err := c.ShouldBindJSON(&req); err != nil {
		fmt.Printf("[UPDATE_USER_INFO] JSON解析失败: %v\n", err)
		c.JSON(http.StatusBadRequest, gin.H{
			"code":    "INVALID_JSON_FORMAT",
			"message": "请求参数格式错误",
			"data":    gin.H{"details": "请检查JSON格式是否正确"},
		})
		return
	}

	// 通过邮箱查找用户
	fmt.Printf("[UPDATE_USER_INFO] 查找用户 - 邮箱: %s\n", email)
	user, err := userService.GetUserByEmail(email)
	if err != nil || user == nil {
		fmt.Printf("[UPDATE_USER_INFO] 用户不存在 - 邮箱: %s\n", email)
		c.JSON(http.StatusNotFound, gin.H{
			"code":    "USER_NOT_FOUND",
			"message": "用户不存在",
			"data":    gin.H{"details": "未找到指定邮箱的用户"},
		})
		return
	}

	fmt.Printf("[UPDATE_USER_INFO] 开始更新 - 用户ID: %d, 新用户名: %s\n", user.ID, req.Name)
	if err := userService.UpdateUserInfo(int(user.ID), req.Name); err != nil {
		fmt.Printf("[UPDATE_USER_INFO] 更新失败: %v\n", err)
		c.JSON(http.StatusInternalServerError, gin.H{
			"code":    "UPDATE_FAILED",
			"message": "更新用户信息失败",
			"data":    gin.H{"details": "服务器内部错误，请稍后重试"},
		})
		return
	}

	fmt.Printf("[UPDATE_USER_INFO] 更新成功 - 用户ID: %d, 新用户名: %s\n", user.ID, req.Name)
	c.JSON(http.StatusOK, gin.H{
		"code":    "SUCCESS",
		"message": "用户信息更新成功",
		"data":    gin.H{"name": req.Name},
	})
}

// SearchUsers 搜索用户
func SearchUsers(c *gin.Context) {
	keyword := c.Query("keyword")
	fmt.Printf("[SEARCH_USERS] 收到搜索请求 - 关键词: %s\n", keyword)

	if keyword == "" {
		fmt.Printf("[SEARCH_USERS] 搜索关键词为空\n")
		c.JSON(http.StatusBadRequest, gin.H{
			"code":    "MISSING_SEARCH_KEYWORD",
			"message": "搜索关键词不能为空",
			"data":    gin.H{"details": "请输入搜索关键词"},
		})
		return
	}

	// 从请求中获取当前用户ID（这里需要根据实际的认证方式调整）
	currentUserID := 0 // 暂时设为0，实际应该从token或session中获取

	users, err := userService.SearchUsers(keyword, currentUserID)
	if err != nil {
		fmt.Printf("[SEARCH_USERS] 搜索失败: %v\n", err)
		c.JSON(http.StatusInternalServerError, gin.H{
			"code":    "SEARCH_FAILED",
			"message": "搜索失败",
			"data":    gin.H{"details": "服务器内部错误，请稍后重试"},
		})
		return
	}

	fmt.Printf("[SEARCH_USERS] 搜索成功 - 关键词: %s, 结果数量: %d\n", keyword, len(users))
	c.JSON(http.StatusOK, gin.H{
		"code":    "SUCCESS",
		"message": "搜索成功",
		"data":    users,
	})
}

// GetUserByEmail 通过邮箱获取用户信息
func GetUserByEmail(c *gin.Context) {
	email := c.Param("email")
	fmt.Printf("[GET_USER_BY_EMAIL] 收到获取用户信息请求 - 邮箱: %s\n", email)

	user, err := userService.GetUserByEmail(email)
	if err != nil || user == nil {
		fmt.Printf("[GET_USER_BY_EMAIL] 用户不存在 - 邮箱: %s, 错误: %v\n", email, err)
		c.JSON(http.StatusNotFound, gin.H{
			"code":    "USER_NOT_FOUND",
			"message": "用户不存在",
			"data":    gin.H{"details": "未找到指定邮箱的用户"},
		})
		return
	}
	user.Password = ""

	fmt.Printf("[GET_USER_BY_EMAIL] 获取成功 - 用户ID: %d, 邮箱: %s\n", user.ID, user.Email)

	// 确保ID字段正确序列化
	userData := gin.H{
		"id":         user.ID,
		"name":       user.Name,
		"email":      user.Email,
		"role":       user.Role,
		"status":     user.Status,
		"level":      user.Level,
		"points":     user.Points,
		"avatar":     user.Avatar,
		"created_at": user.CreatedAt,
		"last_login": user.LastLogin,
	}

	c.JSON(http.StatusOK, gin.H{
		"code":    "SUCCESS",
		"message": "获取用户信息成功",
		"data":    userData,
	})
}

// GetUserCount 获取用户数量
func GetUserCount(c *gin.Context) {
	fmt.Printf("[GET_USER_COUNT] 收到获取用户数量请求\n")

	count, err := userService.GetUserCount()
	if err != nil {
		fmt.Printf("[GET_USER_COUNT] 获取失败: %v\n", err)
		c.JSON(http.StatusInternalServerError, gin.H{
			"code":    "GET_COUNT_FAILED",
			"message": "获取用户数量失败",
			"data":    gin.H{"details": "服务器内部错误，请稍后重试"},
		})
		return
	}

	fmt.Printf("[GET_USER_COUNT] 获取成功 - 用户数量: %d\n", count)
	c.JSON(http.StatusOK, gin.H{
		"code":    "SUCCESS",
		"message": "获取用户数量成功",
		"data":    gin.H{"count": count},
	})
}

// GetUserById 根据用户ID获取用户信息
func GetUserById(c *gin.Context) {
	fmt.Printf("[GET_USER_BY_ID] 收到根据ID查询用户请求 - ID: %s\n", c.Param("id"))

	userIDStr := c.Param("id")

	// 将字符串ID转换为uint
	userID, err := strconv.ParseUint(userIDStr, 10, 32)
	if err != nil {
		fmt.Printf("[GET_USER_BY_ID] ID格式错误 - ID: %s, 错误: %v\n", userIDStr, err)
		c.JSON(http.StatusBadRequest, gin.H{
			"code":    "INVALID_ID",
			"message": "用户ID格式错误",
			"data":    gin.H{"details": "用户ID必须是数字"},
		})
		return
	}

	user, err := userService.GetUserByNumericID(uint(userID))
	if err != nil || user == nil {
		fmt.Printf("[GET_USER_BY_ID] 用户不存在 - ID: %d, 错误: %v\n", userID, err)
		c.JSON(http.StatusNotFound, gin.H{
			"code":    "USER_NOT_FOUND",
			"message": "用户不存在",
			"data":    gin.H{"details": "未找到指定ID的用户"},
		})
		return
	}
	user.Password = ""

	// 确保CreatedAt字段有正确的值
	if user.CreatedAt.IsZero() {
		user.CreatedAt = user.Model.CreatedAt
	}

	fmt.Printf("[GET_USER_BY_ID] 获取成功 - 用户ID: %d, 邮箱: %s\n", user.ID, user.Email)

	// 确保ID字段正确序列化
	userData := gin.H{
		"id":         user.ID,
		"name":       user.Name,
		"email":      user.Email,
		"role":       user.Role,
		"status":     user.Status,
		"level":      user.Level,
		"points":     user.Points,
		"avatar":     user.Avatar,
		"created_at": user.CreatedAt,
		"last_login": user.LastLogin,
	}

	c.JSON(http.StatusOK, gin.H{
		"code":    "SUCCESS",
		"message": "获取用户信息成功",
		"data":    userData,
	})
}

// validateSyncRequest 验证同步请求参数
func validateSyncRequest(req *struct {
	OfflineID string `json:"offline_id"`
	Username  string `json:"username"`
	Email     string `json:"email"`
	Password  string `json:"password"`
	Role      string `json:"role"`
	Avatar    string `json:"avatar"`
	CreatedAt string `json:"created_at"`
	UpdatedAt string `json:"updated_at"`
}) error {
	// 验证密码是否提供
	if req.Password == "" {
		return fmt.Errorf("PASSWORD_REQUIRED")
	}

	// 密码强度验证
	if len(req.Password) < 8 {
		return fmt.Errorf("PASSWORD_TOO_SHORT")
	}

	return nil
}

// createNewSyncUser 创建新的同步用户
func createNewSyncUser(req *struct {
	OfflineID string `json:"offline_id"`
	Username  string `json:"username"`
	Email     string `json:"email"`
	Password  string `json:"password"`
	Role      string `json:"role"`
	Avatar    string `json:"avatar"`
	CreatedAt string `json:"created_at"`
	UpdatedAt string `json:"updated_at"`
}) (*models.User, error) {
	fmt.Printf("[SYNC_USER] 用户不存在，创建新用户 - 邮箱: %s\n", req.Email)

	// 如果OfflineID为空，生成一个新的
	offlineID := req.OfflineID
	if offlineID == "" {
		offlineID = fmt.Sprintf("offline_%d", time.Now().UnixNano())
	}

	newUser := &models.User{
		OfflineID: offlineID,
		Name:      req.Username,
		Email:     req.Email,
		Password:  req.Password, // 这里传入明文密码，Register方法会自动加密
		Role:      req.Role,     // 使用同步的角色信息
		Status:    models.StatusActive,
	}

	// 如果有头像信息，设置头像
	if req.Avatar != "" {
		newUser.Avatar = req.Avatar
	}

	// 如果有创建时间信息，设置创建时间
	if req.CreatedAt != "" {
		if createdAt, err := time.Parse(time.RFC3339, req.CreatedAt); err == nil {
			newUser.CreatedAt = createdAt
		}
	}

	// 使用现有的Register方法，它会自动处理密码加密
	if err := userService.Register(newUser); err != nil {
		return nil, err
	}

	utils.Logger.Info().Uint("user_id", newUser.ID).Str("offline_id", newUser.OfflineID).Str("email", req.Email).Msg("同步创建新用户成功")
	return newUser, nil
}

// updateExistingUser 更新现有用户信息
func updateExistingUser(user *models.User, req *struct {
	OfflineID string `json:"offline_id"`
	Username  string `json:"username"`
	Email     string `json:"email"`
	Password  string `json:"password"`
	Role      string `json:"role"`
	Avatar    string `json:"avatar"`
	CreatedAt string `json:"created_at"`
	UpdatedAt string `json:"updated_at"`
}) error {
	updated := false

	// 更新离线ID（如果为空）
	if user.OfflineID == "" && req.OfflineID != "" {
		fmt.Printf("[SYNC_USER] 更新用户离线ID - 用户ID: %d, 新离线ID: %s\n", user.ID, req.OfflineID)
		user.OfflineID = req.OfflineID
		updated = true
	}

	// 更新角色（如果不同）
	if req.Role != "" && user.Role != req.Role {
		fmt.Printf("[SYNC_USER] 更新用户角色 - 用户ID: %d, 新角色: %s\n", user.ID, req.Role)
		user.Role = req.Role
		updated = true
	}

	// 更新头像（如果不同）
	if req.Avatar != "" && user.Avatar != req.Avatar {
		fmt.Printf("[SYNC_USER] 更新用户头像 - 用户ID: %d\n", user.ID)
		user.Avatar = req.Avatar
		updated = true
	}

	// 更新用户名（如果不同）
	if req.Username != "" && user.Name != req.Username {
		fmt.Printf("[SYNC_USER] 更新用户名 - 用户ID: %d, 新用户名: %s\n", user.ID, req.Username)
		user.Name = req.Username
		updated = true
	}

	// 如果有更新，保存到数据库
	if updated {
		if err := models.GetDB().Save(user).Error; err != nil {
			return err
		}
		utils.Logger.Info().Uint("user_id", user.ID).Str("email", user.Email).Msg("同步更新用户信息成功")
	}

	fmt.Printf("[SYNC_USER] 用户已存在 - 用户ID: %d, 离线ID: %s\n", user.ID, user.OfflineID)
	return nil
}

// SyncUserData 用户数据同步接口
func SyncUserData(c *gin.Context) {
	fmt.Printf("[SYNC_USER] 收到用户数据同步请求 - IP: %s\n", c.ClientIP())

	var req struct {
		OfflineID string `json:"offline_id"`
		Username  string `json:"username"`
		Email     string `json:"email"`
		Password  string `json:"password"`   // 用户同步时设置的新密码
		Role      string `json:"role"`       // 用户角色
		Avatar    string `json:"avatar"`     // 用户头像
		CreatedAt string `json:"created_at"` // 创建时间
		UpdatedAt string `json:"updated_at"` // 更新时间
	}

	if err := c.ShouldBindJSON(&req); err != nil {
		utils.Logger.Error().Err(err).Str("ip", c.ClientIP()).Msg("用户数据同步JSON解析失败")
		c.JSON(http.StatusBadRequest, gin.H{
			"code":    "INVALID_JSON_FORMAT",
			"message": "请求参数格式错误",
			"data":    gin.H{"details": "请检查JSON格式是否正确"},
		})
		return
	}

	fmt.Printf("[SYNC_USER] 解析成功 - 离线ID: %s, 用户名: %s, 邮箱: %s\n", req.OfflineID, req.Username, req.Email)

	// 验证请求参数
	if err := validateSyncRequest(&req); err != nil {
		switch err.Error() {
		case "PASSWORD_REQUIRED":
			fmt.Printf("[SYNC_USER] 密码未提供 - 邮箱: %s\n", req.Email)
			c.JSON(http.StatusBadRequest, gin.H{
				"code":    "PASSWORD_REQUIRED",
				"message": "数据同步需要设置密码",
				"data": gin.H{
					"details":    "请设置一个密码来完成数据同步",
					"suggestion": "这是您首次将本地数据同步到服务器，需要设置一个密码来保护您的账户",
				},
			})
		case "PASSWORD_TOO_SHORT":
			fmt.Printf("[SYNC_USER] 密码强度验证失败 - 密码长度: %d\n", len(req.Password))
			c.JSON(http.StatusBadRequest, gin.H{
				"code":    "PASSWORD_TOO_SHORT",
				"message": "密码长度不足",
				"data":    gin.H{"details": "密码长度至少需要8位字符"},
			})
		}
		return
	}

	// 1. 根据邮箱查询用户是否存在
	var user models.User
	err := models.GetDB().Where("email = ?", req.Email).First(&user).Error

	if err != nil {
		// 2. 用户不存在，创建新用户（本地用户首次同步）
		if errors.Is(err, gorm.ErrRecordNotFound) {
			newUser, createErr := createNewSyncUser(&req)
			if createErr != nil {
				utils.Logger.Error().Err(createErr).Str("email", req.Email).Msg("同步创建用户失败")
				c.JSON(http.StatusInternalServerError, gin.H{
					"code":    "CREATE_USER_FAILED",
					"message": "创建用户失败",
					"data":    gin.H{"details": "服务器内部错误，请稍后重试"},
				})
				return
			}
			user = *newUser
		} else {
			utils.Logger.Error().Err(err).Str("email", req.Email).Msg("同步查询用户失败")
			c.JSON(http.StatusInternalServerError, gin.H{
				"code":    "QUERY_USER_FAILED",
				"message": "查询用户失败",
				"data":    gin.H{"details": "服务器内部错误，请稍后重试"},
			})
			return
		}
	} else {
		// 3. 用户存在，更新用户信息
		if err := updateExistingUser(&user, &req); err != nil {
			utils.Logger.Error().Err(err).Uint("user_id", user.ID).Str("email", req.Email).Msg("同步更新用户信息失败")
			c.JSON(http.StatusInternalServerError, gin.H{
				"code":    "UPDATE_USER_FAILED",
				"message": "更新用户信息失败",
				"data":    gin.H{"details": "服务器内部错误，请稍后重试"},
			})
			return
		}
	}

	// 4. 返回用户数据（包含服务器ID）
	utils.Logger.Info().Uint("user_id", user.ID).Str("offline_id", user.OfflineID).Str("email", user.Email).Msg("用户数据同步成功")
	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"user": gin.H{
			"id":         user.ID,        // 服务器主键ID
			"offline_id": user.OfflineID, // 13位离线ID
			"name":       user.Name,
			"email":      user.Email,
			"role":       user.Role,
			"status":     user.Status,
		},
	})
}
